home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 242 / Issue 242 - April 2008 - DPCS0408DVD.ISO / Software Money Savers / VirtualDub / Source / VirtualDub-1.7.7-src.7z / src / h / vd2 / system / math.h < prev    next >
Encoding:
C/C++ Source or Header  |  2007-10-13  |  6.1 KB  |  246 lines
  1. //    VirtualDub - Video processing and capture application
  2. //    System library component
  3. //    Copyright (C) 1998-2004 Avery Lee, All Rights Reserved.
  4. //
  5. //    Beginning with 1.6.0, the VirtualDub system library is licensed
  6. //    differently than the remainder of VirtualDub.  This particular file is
  7. //    thus licensed as follows (the "zlib" license):
  8. //
  9. //    This software is provided 'as-is', without any express or implied
  10. //    warranty.  In no event will the authors be held liable for any
  11. //    damages arising from the use of this software.
  12. //
  13. //    Permission is granted to anyone to use this software for any purpose,
  14. //    including commercial applications, and to alter it and redistribute it
  15. //    freely, subject to the following restrictions:
  16. //
  17. //    1.    The origin of this software must not be misrepresented; you must
  18. //        not claim that you wrote the original software. If you use this
  19. //        software in a product, an acknowledgment in the product
  20. //        documentation would be appreciated but is not required.
  21. //    2.    Altered source versions must be plainly marked as such, and must
  22. //        not be misrepresented as being the original software.
  23. //    3.    This notice may not be removed or altered from any source
  24. //        distribution.
  25.  
  26. #ifndef f_VD2_SYSTEM_MATH_H
  27. #define f_VD2_SYSTEM_MATH_H
  28.  
  29. #include <math.h>
  30. #include <vd2/system/vdtypes.h>
  31.  
  32. // Constants
  33. namespace nsVDMath {
  34.     static const float    kfPi = 3.1415926535897932384626433832795f;
  35.     static const float    krPi = 3.1415926535897932384626433832795;
  36.     static const double    kfTwoPi = 6.283185307179586476925286766559f;
  37.     static const double    krTwoPi = 6.283185307179586476925286766559;
  38.     static const float    kfLn2 = 0.69314718055994530941723212145818f;
  39.     static const double    krLn2 = 0.69314718055994530941723212145818;
  40.     static const float    kfLn10 = 2.3025850929940456840179914546844f;
  41.     static const double    krLn10 = 2.3025850929940456840179914546844;
  42.     static const float    kfOneOverLn10 = 0.43429448190325182765112891891661f;
  43.     static const double    krOneOverLn10 = 0.43429448190325182765112891891661;
  44. };
  45.  
  46. ///////////////////////////////////////////////////////////////////////////
  47. // Integer clamping functions
  48. //
  49. #ifdef _M_IX86
  50.     inline uint32 VDClampToUint32(sint64 v) {
  51.         union U {
  52.             __int64 v64;
  53.             struct {
  54.                 unsigned lo;
  55.                 int hi;
  56.             } v32;
  57.         };
  58.  
  59.         return ((U *)&v)->v32.hi ? ~(((U *)&v)->v32.hi >> 31) : ((U *)&v)->v32.lo;
  60.     }
  61. #else
  62.     inline uint32 VDClampToUint32(sint64 v) {
  63.         uint32 r = (uint32)v;
  64.         return r == v ? r : (uint32)~(sint32)(v>>63);
  65.     }
  66. #endif
  67.  
  68. inline sint32 VDClampToSint32(sint64 v) {
  69.     sint32 r = (sint32)v;
  70.     return r == v ? r : (sint32)(v >> 63) ^ 0x7FFFFFFF;
  71. }
  72.  
  73. ///////////////////////////////////////////////////////////////////////////
  74. // Absolute value functions
  75. inline sint64 VDAbs64(sint64 v) {
  76.     return v<0 ? -v : v;
  77. }
  78.  
  79. inline ptrdiff_t VDAbsPtrdiff(ptrdiff_t v) {
  80.     return v<0 ? -v : v;
  81. }
  82.  
  83. // Rounding functions
  84. //
  85. // Round a double to an int or a long.  Behavior is not specified at
  86. // int(y)+0.5, if x is NaN or Inf, or if x is out of range.
  87.  
  88. int VDRoundToInt(double x);
  89. long VDRoundToLong(double x);
  90. sint32 VDRoundToInt32(double x);
  91. sint64 VDRoundToInt64(double x);
  92.  
  93. inline sint32 VDRoundToIntFast(float x) {
  94.     union {
  95.         float f;
  96.         sint32 i;
  97.     } u = {x + 12582912.0f};        // 2^22+2^23
  98.  
  99.     return (sint32)u.i - 0x4B400000;
  100. }
  101.  
  102. inline sint32 VDRoundToIntFastFullRange(double x) {
  103.     union {
  104.         double f;
  105.         sint32 i[2];
  106.     } u = {x + 6755399441055744.0f};        // 2^51+2^52
  107.  
  108.     return (sint32)u.i[0];
  109. }
  110.  
  111. #ifdef _M_AMD64
  112.     inline sint32 VDFloorToInt(double x) {
  113.         return (sint32)floor(x);
  114.     }
  115.  
  116.     inline sint64 VDFloorToInt64(double x) {
  117.         return (sint64)floor(x);
  118.     }
  119. #else
  120.     #pragma warning(push)
  121.     #pragma warning(disable: 4035)        // warning C4035: 'VDFloorToInt' : no return value
  122.     inline sint32 VDFloorToInt(double x) {
  123.         sint32 temp;
  124.  
  125.         __asm {
  126.             fld x
  127.             fist temp
  128.             fild temp
  129.             mov eax, temp
  130.             fsub
  131.             fstp temp
  132.             cmp    temp, 80000001h
  133.             adc eax, -1
  134.         }
  135.     }
  136.     inline sint64 VDFloorToInt64(double x) {
  137.         sint64 temp;
  138.         sint32 temp2;
  139.  
  140.         __asm {
  141.             fld x
  142.             fld st(0)
  143.             fistp qword ptr temp
  144.             fild qword ptr temp
  145.             mov eax, dword ptr temp
  146.             mov edx, dword ptr temp+4
  147.             fsub
  148.             fstp dword ptr temp2
  149.             cmp    dword ptr temp2, 80000001h
  150.             adc eax, -1
  151.             adc edx, -1
  152.         }
  153.     }
  154.     #pragma warning(pop)
  155. #endif
  156.  
  157. #ifdef _M_AMD64
  158.     inline sint32 VDCeilToInt(double x) {
  159.         return (sint32)ceil(x);
  160.     }
  161.  
  162.     inline sint64 VDCeilToInt64(double x) {
  163.         return (sint64)ceil(x);
  164.     }
  165. #else
  166.     #pragma warning(push)
  167.     #pragma warning(disable: 4035)        // warning C4035: 'VDCeilToInt' : no return value
  168.     inline sint32 VDCeilToInt(double x) {
  169.         sint32 temp;
  170.  
  171.         __asm {
  172.             fld x
  173.             fist temp
  174.             fild temp
  175.             mov eax, temp
  176.             fsubr
  177.             fstp temp
  178.             cmp    temp, 80000001h
  179.             sbb eax, -1
  180.         }
  181.     }
  182.  
  183.     inline sint32 VDCeilToInt64(double x) {
  184.         sint64 temp;
  185.         sint32 temp2;
  186.  
  187.         __asm {
  188.             fld x
  189.             fld st(0)
  190.             fistp temp
  191.             fild temp
  192.             mov eax, dword ptr temp
  193.             mov edx, dword ptr temp+4
  194.             fsubr
  195.             fstp temp2
  196.             cmp    temp2, 80000001h
  197.             sbb eax, -1
  198.             sbb edx, -1
  199.         }
  200.     }
  201.     #pragma warning(pop)
  202. #endif
  203.  
  204. ///////////////////////////////////////////////////////////////////////////
  205. inline sint16 VDClampedRoundFixedToInt16Fast(float x) {
  206.     union {
  207.         float f;
  208.         sint32 i;
  209.     } u = {x + 384.0f};        // 2^7+2^8
  210.  
  211.     sint32 v = (sint32)u.i - 0x43BF8000;
  212.  
  213.     if ((uint32)v >= 0x10000)
  214.         v = ~v >> 31;
  215.  
  216.     return (sint16)(v - 0x8000);
  217. }
  218.  
  219. inline uint8 VDClampedRoundFixedToUint8Fast(float x) {
  220.     union {
  221.         float f;
  222.         sint32 i;
  223.     } u = {x * 255.0f + 12582912.0f};        // 2^22+2^23
  224.  
  225.     sint32 v = (sint32)u.i - 0x4B400000;
  226.  
  227.     if ((uint32)v >= 0xFF)
  228.         v = ~v >> 31;
  229.  
  230.     return (uint8)v;
  231. }
  232.  
  233. ///////////////////////////////////////////////////////////////////////////
  234.  
  235. #ifdef _M_IX86
  236.     sint64 __stdcall VDFractionScale64(uint64 a, uint32 b, uint32 c, uint32& remainder);
  237.     uint64 __stdcall VDUMulDiv64x32(uint64 a, uint32 b, uint32 c);
  238. #else
  239.     extern "C" sint64 VDFractionScale64(uint64 a, uint64 b, uint64 c, uint32& remainder);
  240.     extern "C" uint64 VDUMulDiv64x32(uint64 a, uint32 b, uint32 c);
  241. #endif
  242.  
  243. sint64 VDMulDiv64(sint64 a, sint64 b, sint64 c);
  244.  
  245. #endif
  246.